package br.com.fogas.notafiscal;

import java.math.BigDecimal;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang3.SerializationUtils;

import com.j256.ormlite.dao.ForeignCollection;

import br.com.fogas.database.FogasDatabase;
import br.com.fogas.database.entidade.Config;
import br.com.fogas.database.entidade.NotaControle;
import br.com.fogas.database.entidade.NotaFiscal;
import br.com.fogas.database.entidade.NotaItem;
import br.com.fogas.database.entidade.NotaItemCondicoes;
import br.com.fogas.database.entidade.PlanoVisitas;
import br.com.fogas.database.enums.PlanoVisitaStatusEnum;
import br.com.fogas.database.enums.StatusNotaEnum;
import br.com.fogas.database.exception.CondicoesPrecoException;
import br.com.fogas.modelo.Configuracao;
import br.com.fogas.notafiscal.condicoes.zfd1.CondicaoZFD1;
import br.com.fogas.notafiscal.condicoes.zfd2.CondicaoZFD2;
import br.com.fogas.notafiscal.condicoes.zfd3.CondicaoZFD3;
import br.com.fogas.notafiscal.condicoes.zfd5.CondicaoZFD5;
import br.com.fogas.notafiscal.enums.CondicoesEnum;
import br.com.fogas.notafiscal.enums.TipoEmissaoNotaEnum;
import br.com.fogas.notafiscal.exception.ClienteBloqueadoSefazException;
import br.com.fogas.notafiscal.exception.ClienteBloquedoException;
import br.com.fogas.notafiscal.exception.NotaFiscalException;
import br.com.fogas.notafiscal.exception.NotaNaoAutorizadaException;
import br.com.fogas.notafiscal.exception.NotaNaoEmitidaException;
import br.com.fogas.notafiscal.modelo.NF;
import br.com.fogas.notafiscal.modelo.NFItem;
import br.com.fogas.utils.DateUtility;
import br.com.fogas.utils.FogasUtility;
import br.com.fogas.utils.StringUtility;
import br.com.fogas.webservice.exception.SemConexaoInternetException;
import br.com.fogas.webservice.parser.notafiscal.NotaFiscalRequest;
import br.com.fogas.webservice.parser.notafiscal.NotaFiscalRequestBuilder;
import br.com.fogas.webservice.parser.notafiscal.NotaFiscalResponse;
import br.com.fogas.webservice.parser.notafiscal.NotaFiscalResponseBody;
import br.com.fogas.webservice.parser.notafiscal.NotaItemCondicaoBuilder;
import br.com.fogas.webservice.parser.notafiscal.NotaItemRequestBuilder;
import br.com.fogas.webservice.parser.notafiscal.situacao.BnfeActiveItem;
import br.com.fogas.webservice.parser.notafiscal.situacao.NotaFiscalSitRequest;
import br.com.fogas.webservice.parser.notafiscal.situacao.NotaFiscalSitResponse;
import br.com.fogas.webservice.service.FogasWebservice;

public class NotaFiscalEngine {
	
	public static void cancelarNota(FogasDatabase database, NotaFiscal notaFiscal) throws SQLException {
		notaFiscal.setCs_cancelada(true);
		notaFiscal.setNb_sync(StatusNotaEnum.PENDENTE.getId());
		database.getNotaFiscal().update(notaFiscal);
		
		PlanoVisitas planoVisitas = notaFiscal.getTx_plano_visitas();
		planoVisitas.setStatus(PlanoVisitaStatusEnum.PENDENTE.getId());
		database.getPlanoVisitas().update(planoVisitas);
	}
	
	public static boolean notaAutorizada(FogasWebservice webservice, FogasDatabase database, NotaFiscal notaFiscal)
			throws ClienteBloqueadoSefazException, NotaNaoAutorizadaException {
		NotaFiscalSitRequest request = new NotaFiscalSitRequest();
		request.setNfNum(notaFiscal.getTx_nfnum());
		request.setNfSerie(notaFiscal.getTx_serie());
		request.setOrgVendas(notaFiscal.getTx_canal().getTx_org_vendas());
		
		try {
			NotaFiscalSitResponse response = webservice.notaFiscalSituacao(request).getResponse();
			
			boolean bloqueadoSefaz = StringUtility.equals(response.getStatus(), "2") 
					|| StringUtility.equals(response.getStatus(), "3");
			if(bloqueadoSefaz) {
				notaFiscal.setCs_recusada(true);
				notaFiscal.setCs_cancelada(true);
				notaFiscal.setCs_simulacao(false);
				notaFiscal.setNb_sync(StatusNotaEnum.SINCRONIZADA.getId());
				throw new ClienteBloqueadoSefazException();
			}
			
			boolean notaAutorizada = StringUtility.equals(response.getStatus(), "C");
			if(notaAutorizada) {
				Config config = database.getConfig().queryForId(1);
				
				BnfeActiveItem notaResponse = response.getBnfeActive().getItem();
				
				String chaveAcesso = FogasUtility.NFe.geraChaveNFe(
						config.getTx_centro(), 
						notaFiscal.getDt_entrega(), 
						config.getTx_cnpj(), 
						notaFiscal.getTx_serie(), 
						notaFiscal.getTx_nfnum(), 
						String.valueOf(TipoEmissaoNotaEnum.ONLINE.getId()));
				
				boolean contingencia = false;
				if(notaResponse.getCONTING() != null) {
					contingencia = StringUtility.isNotEmpty(notaResponse.getCONTING());
				}
				
				notaFiscal.setTx_chave_acesso(chaveAcesso);
				notaFiscal.setTx_protocolo(notaResponse.getAUTHCOD());
				notaFiscal.setCs_contigencia(contingencia);
				notaFiscal.setCs_simulacao(false);
				notaFiscal.setNb_sync(StatusNotaEnum.SINCRONIZADA.getId());
			} else {
				notaFiscal.setCs_cancelada(true);
				notaFiscal.setCs_simulacao(false);
				notaFiscal.setNb_sync(StatusNotaEnum.PENDENTE.getId());
			}
			
			return notaAutorizada;		
		} catch (Exception e) {
			if(e instanceof ClienteBloqueadoSefazException) {
				throw new ClienteBloqueadoSefazException("NF-e nao foi autorizada pela Sefaz. O cliente deve entrar em contato com a Fog�s.");
			} else {
				notaFiscal.setCs_cancelada(true);
				notaFiscal.setCs_simulacao(false);
				notaFiscal.setNb_sync(StatusNotaEnum.PENDENTE.getId());
				
				throw new NotaNaoAutorizadaException("Nao foi possivel autorizar a nota na sefaz!");
			}
		}
	}
	
	public static void enviarNotaFogas(FogasWebservice webservice, Configuracao configuracao, 
			NotaFiscal notaFiscal) throws NotaNaoEmitidaException {
		List<NotaFiscal> notas = new ArrayList<NotaFiscal>();
		notas.add(notaFiscal);
		NotaFiscalRequest request = requestWebserviceNotaFiscal(configuracao, notas);
		try {
			NotaFiscalResponse response = webservice.notaFiscal(request).getResponse();
			NotaFiscalResponseBody notaFiscalResponse = response.getItem().getItems().get(0);
			if(!notaFiscalResponse.getGravada().equals("X")) {
				throw new NotaNaoEmitidaException();
			}
		} catch (Exception e) {
			if(e instanceof SemConexaoInternetException) {
				throw new NotaNaoEmitidaException("Sem internet no momento do envio da nota!");
			} else {
				throw new NotaNaoEmitidaException("Nao foi possivel enviar a nota online!");
			}
		}
	}
	
	public static NotaFiscalRequest requestWebserviceNotaFiscal(
			Configuracao configuracao, List<NotaFiscal> notas) {
		NotaFiscalRequestBuilder notaBuilder = new NotaFiscalRequestBuilder();
		
		for(NotaFiscal notaFiscal: notas) {
			notaBuilder.nfNum(notaFiscal.getTx_nfnum())
			.nfSerie(notaFiscal.getTx_serie())
			.data(notaFiscal.getDt_nota())
			.hora(notaFiscal.getDt_hora())
			.vencimento(notaFiscal.getDt_vencimento())
			.condPgto(notaFiscal.getTx_cond_pagto().getTx_cod())
			.codCliente(notaFiscal.getTx_cod_cliente().getTx_cod_cliente())
			.cancelada(notaFiscal.isCs_cancelada())
			.pesoBruto(notaFiscal.getVl_peso_bruto().doubleValue())
			.pesoLiquido(notaFiscal.getVl_peso_liquido().doubleValue())
			.nossoNumero(notaFiscal.getTx_nosso_numero())
			.canal(notaFiscal.getTx_canal().getTx_canal())
			.setor(notaFiscal.getTx_canal().getTx_setor())
			.valorNota(notaFiscal.getVl_valor_nota().doubleValue())
			.contigencia(notaFiscal.isCs_contigencia())
			.medidor(notaFiscal.getTx_medidor().getTx_cod_medidor())
			.leituraAtual(notaFiscal.getTx_medidor().getNb_leitura_atual())
			.qrCodeLido(notaFiscal.isCs_qrCode_lido())
			.plano(configuracao.getAppDados().getPlano())
			.adicionarNota();
			
			for(NotaItem notaItem: notaFiscal.getNotaItems()) {
				NotaItemRequestBuilder itemBuilder = new NotaItemRequestBuilder()
				.posicaoSap(notaItem.getTx_posicao_sap())
				.nfNum(notaItem.getTx_nota_fiscal().getTx_nfnum())
				.nfSerie(notaItem.getTx_nota_fiscal().getTx_serie())
				.material(notaItem.getTx_material().getTx_cod_material())
				.quantidade(notaItem.getNb_qtde())
				.valorUnitario(notaItem.getVl_unitario())
				.unidade(notaItem.getTx_material().getTx_und())
				.valorTotal(notaItem.getVl_total())
				.valorIcms(notaItem.getVl_icms())
				.valorAliquota(notaItem.getTx_material().getVl_aliquota());
				notaBuilder.adicionaItem(itemBuilder.item());
				
				for(NotaItemCondicoes condicao: notaItem.getItemCondicoes()) {
					NotaItemCondicaoBuilder condicaoBuilder = new NotaItemCondicaoBuilder()
					.posicaoSap(condicao.getTx_nota_item().getTx_posicao_sap())
					.condicao(condicao.getTx_condicao())
					.nfNum(condicao.getTx_nota_item().getTx_nota_fiscal().getTx_nfnum())
					.nfSerie(condicao.getTx_nota_item().getTx_nota_fiscal().getTx_serie())
					.valorTotal(condicao.getVl_total())
					.valorUnitario(condicao.getVl_unitario());
					notaBuilder.adicionaCondicao(condicaoBuilder.condicao());
				}
			}
		}
		return notaBuilder.request();
	}
	
	public static NotaFiscal gerarNotaFiscalSimulacao(FogasDatabase database, NF nf) throws Exception {
		try {
			boolean clienteBloqueado = nf.getCliente().getTx_cod_sit_cred() == "01";
			if (!clienteBloqueado) {
				zerarVariaveisSimulacao();
				database.getNotaFiscal().limparSimulacoes();
				NotaFiscal notaFiscal = gerarNotaSimulacao(database, nf);
				itemsNotaSimulacao(database, notaFiscal, nf.getItems());
				descontoItems(database, nf.getItems());
				atualizarValoresNotaFiscalSimulacao(notaFiscal, nf.getItems());
				geraBoleto(notaFiscal);
				return salvarSimulacao(database, notaFiscal, nf.getItems());
			} else {
				throw new ClienteBloquedoException("Cliente bloqueado, nenhuma nota será emitida. Sit. de cr�dito 01.");
			}
		} catch (Exception e) {
			if(e instanceof ClienteBloquedoException) {
				throw e;
			} 
			throw new NotaFiscalException(e.getMessage());
		}
	}
	
	private static void zerarVariaveisSimulacao() {
		descontoBoleto = 0;
		descontosCondicoes = 0;
		pesoBrutoNota = 0;
		pesoLiquidoNota = 0;
		valorSomaItems = 0;
		icmsNota = 0;
		icmsBaseNota = 0;
		valorTotalNota = 0;
		quantidades = 0;
	}
	
	private static NotaFiscal gerarNotaSimulacao(FogasDatabase database, NF nf) throws Exception {
		try {
			NotaFiscal notaFiscal = new NotaFiscal();
			NotaControle notaControle = NotaFiscalUtils.proximaNota(database);
			notaFiscal.setTx_nfnum(notaControle.getTx_ultima_nota());
			notaFiscal.setTx_serie(notaControle.getTx_serie());
			notaFiscal.setTx_cod_cliente(nf.getCliente());
			notaFiscal.setTx_cfop(Constants.CFOP);
			notaFiscal.setNb_tp_nota(nf.getTipoDeNota().getId());
			notaFiscal.setDt_nota(nf.getDataNota());
			notaFiscal.setDt_entrega(nf.getDataEntrega());
			notaFiscal.setDt_hora(nf.getDataHora());
			notaFiscal.setCs_simulacao(true);
			notaFiscal.setCs_impressa(false);
			notaFiscal.setCs_cancelada(false);
			notaFiscal.setCs_recusada(false);
			notaFiscal.setCs_contigencia(false);
			notaFiscal.setNb_sync(StatusNotaEnum.PENDENTE.getId());
			notaFiscal.setTx_canal(nf.getCanal());
			notaFiscal.setTx_cond_pagto(nf.getCondicaoPagto());
			notaFiscal.setCs_qrCode_lido(nf.isQrCodeLido());
			notaFiscal.setTx_medidor(nf.getMedidor());
			return notaFiscal;
		} catch (Exception e) {
			throw new Exception("error ocorrido metodo gerarNotaSimulacao() causa: "+e.getMessage());
		}
	}
	
	private static void geraBoleto(NotaFiscal notaFiscal) {
		//O boleto sera gerado somente pagto a prazo
		if(!Constants.COND_VISTA.equals(notaFiscal.getTx_cond_pagto().getTx_cod())) {
			Date now = FogasUtility.data.getDateWithoutHour(new Date());
			Date dataVencimento = DateUtility.addDays(now, Integer.valueOf(notaFiscal.getTx_cond_pagto().getNb_dias()));
			
			String nossoNumero = FogasUtility.fogasBoleto.geraNossoNumero(
					notaFiscal.getTx_serie(), 
					notaFiscal.getTx_nfnum(), 
					notaFiscal.getTx_canal().getTx_org_vendas(), 
					true);
			
			String numeroBoleto = FogasUtility.fogasBoleto.geraNumeroBoleto(notaFiscal.getTx_serie(), 
					notaFiscal.getTx_nfnum(), 
					notaFiscal.getTx_canal().getTx_org_vendas(),
					dataVencimento, 
					notaFiscal.getVl_valor_nota().doubleValue());
			
			notaFiscal.setTx_nosso_numero(nossoNumero);
			notaFiscal.setDt_vencimento(dataVencimento);
			notaFiscal.setTx_cod_boleto(numeroBoleto);
		}
	}
	
	private static void itemsNotaSimulacao(FogasDatabase database, NotaFiscal notaFiscal, List<NFItem> items) throws Exception {
		try {
			int posicaoItem = 10;
			
			for(NFItem item : items) {
				BigDecimal valorUnitario = NotaFiscalUtils.precoItemNota(database, item, notaFiscal);
				BigDecimal valorItem = NotaFiscalUtils.valorItemNota(valorUnitario, item.getQuantidade());
				BigDecimal valorItemICMS = NotaFiscalUtils.valorItemICMS(item);
				BigDecimal valorItemBaseICMS = NotaFiscalUtils.valorItemBaseICMS(item);
				
				NotaItem notaItem = new NotaItem();
				notaItem.setTx_nota_fiscal(notaFiscal);
				notaItem.setTx_material(item.getMaterial());
				notaItem.setTx_posicao_sap(String.valueOf(posicaoItem));
				notaItem.setNb_qtde(item.getQuantidade());
				notaItem.setVl_unitario(valorUnitario);
				notaItem.setVl_total(valorItem);
				notaItem.setVl_icms(valorItemICMS);
				notaItem.setVl_base_icms(valorItemBaseICMS);
				notaItem.setTx_cod_icms("060");
				notaItem.setTx_nota_fiscal(notaFiscal);
				item.setNotaItem(notaItem);
				criarCondicaoPrecoNotaItem(notaItem);
				
				posicaoItem += 10;
			}
		} catch (Exception e) {
			throw new Exception("error ocorrido metodo itemsNotaSimulacao() causa: "+e.getMessage());
		}
	}
	
	private static void criarCondicaoPrecoNotaItem(NotaItem notaItem) {
		NotaItemCondicoes itemCondicao = new NotaItemCondicoes();
		itemCondicao.setTx_condicao(CondicoesEnum.ZFP0.getCodigo());
		itemCondicao.setTx_nota_item(notaItem);
		itemCondicao.setVl_total(notaItem.getVl_total());
		itemCondicao.setVl_unitario(notaItem.getVl_unitario());
		
		List<NotaItemCondicoes> condicoes = new ArrayList<NotaItemCondicoes>();
		condicoes.add(itemCondicao);
		notaItem.setItemCondicoesTemp(condicoes);
	}
	
	static double descontoBoleto = 0;
	static double descontosCondicoes = 0;
	
	private static void descontoItems(FogasDatabase database, List<NFItem> items) throws CondicoesPrecoException {
		try {
			for(NFItem item : items) {
				NotaItem notaItem = item.getNotaItem();
			    List<NotaItemCondicoes> condicoes = notaItem.getItemCondicoesTemp();
			    
			    List<NotaItemCondicoes> descontos = descontosItemNota(database, item);
			    if(!descontos.isEmpty())
			    	condicoes.addAll(descontos);
				
				for(NotaItemCondicoes condicao: descontos) {
					//descontoBoleto somente na ZFD3
					if(CondicoesEnum.ZFD3.getCodigo().equals(condicao.getTx_condicao())) {
						descontoBoleto  += condicao.getVl_total().doubleValue();
					} else {
						descontosCondicoes  += condicao.getVl_total().doubleValue();
					}
				}
			}
		} catch (CondicoesPrecoException e) {
			throw new CondicoesPrecoException("error ocorrido metodo descontoItems() causa: "+e.getMessage());
		}			
	}
	
	static double pesoBrutoNota = 0;
	static double pesoLiquidoNota = 0;
	static double valorSomaItems = 0;
	static double icmsNota = 0;
	static double icmsBaseNota = 0;
	static double valorTotalNota = 0;
	static double quantidades = 0;
	
	private static void atualizarValoresNotaFiscalSimulacao(NotaFiscal notaFiscal, List<NFItem> items) {
		for(NFItem item : items) {
			pesoBrutoNota += NotaFiscalUtils.pesoBrutoItemNota(item);
			pesoLiquidoNota += NotaFiscalUtils.pesoLiquidoItemNota(item);
			valorSomaItems += item.getNotaItem().getVl_total().doubleValue();
			icmsNota += item.getNotaItem().getVl_icms().doubleValue();
			icmsBaseNota += item.getNotaItem().getVl_base_icms().doubleValue();
			quantidades += item.getQuantidade().doubleValue();
		}
		
		valorTotalNota = NotaFiscalUtils.valorArredondado(valorSomaItems).doubleValue() + 
				NotaFiscalUtils.valorArredondado(descontosCondicoes).doubleValue();
		notaFiscal.setVl_descontos(NotaFiscalUtils.valorArredondado(descontosCondicoes));
		notaFiscal.setVl_valor_nota(NotaFiscalUtils.valorArredondado(valorTotalNota));
		notaFiscal.setVl_valor_total_produtos(NotaFiscalUtils.valorArredondado(valorSomaItems));
		notaFiscal.setVl_desconto_boleto(NotaFiscalUtils.valorArredondado(descontoBoleto));
		notaFiscal.setVl_peso_bruto(NotaFiscalUtils.valorArredondado(pesoBrutoNota));
		notaFiscal.setVl_peso_liquido(NotaFiscalUtils.valorArredondado(pesoLiquidoNota));
		notaFiscal.setVl_base_icms(NotaFiscalUtils.valorArredondado(icmsBaseNota));
		notaFiscal.setVl_icms(NotaFiscalUtils.valorArredondado(icmsNota));
		notaFiscal.setVl_quantidades(NotaFiscalUtils.valorArredondado(quantidades));
	}
	
	private static List<NotaItemCondicoes> descontosItemNota(FogasDatabase database, NFItem item) throws CondicoesPrecoException {
		List<NotaItemCondicoes> condicoes = new ArrayList<NotaItemCondicoes>();
		
		CondicaoZFD1 descontoZFD1 = new CondicaoZFD1(database, item);
		condicoes.addAll(descontoZFD1.getCondicoes());
		
		CondicaoZFD2 descontoZFD2 = new CondicaoZFD2(database, item);
		condicoes.addAll(descontoZFD2.getCondicoes());
		
		CondicaoZFD3 descontoZFD3 = new CondicaoZFD3(database, item);
		condicoes.addAll(descontoZFD3.getCondicoes());
		
		CondicaoZFD5 descontoZFD5 = new CondicaoZFD5(database, item);
		condicoes.addAll(descontoZFD5.getCondicoes());
		
		return condicoes;
	}
	
	private static NotaFiscal salvarSimulacao(FogasDatabase database, NotaFiscal notaFiscal, List<NFItem> items) throws CondicoesPrecoException {
		try {
			List<NotaItem> notaItems = new ArrayList<NotaItem>();
			
			for(NFItem item : items) {
				NotaItem notaItem = item.getNotaItem();
				notaItem.setTx_nota_fiscal(notaFiscal);
				notaItems.add(notaItem);
				
				for (NotaItemCondicoes condicao : notaItem.getItemCondicoesTemp()) {
					condicao.setTx_nota_item(notaItem);
				}
			} 
			
			notaFiscal.setNotaItemsTemp(notaItems);
			
			NotaFiscal notaGerada = database.getNotaFiscal().gravarSimulacao(notaFiscal);
			
			return notaGerada;
		} catch (Exception e) {
			throw new CondicoesPrecoException("error ocorrido metodo salvarSimulacao() causa: "+e.getMessage());
		}
	}
	
	public static NotaFiscal salvarNotaContigencia(FogasDatabase database, NotaFiscal notaFiscal) throws SQLException {
		NotaControle notaControle = database.getNotaControle().proximaNota();
		Config config = database.getConfig().queryForId(1);
		
		String novaChave = FogasUtility.NFe.geraChaveNFe(
				config.getTx_centro(), 
				notaFiscal.getDt_entrega(),
				config.getTx_cnpj(), 
				notaControle.getTx_serie(),
				notaControle.getTx_ultima_nota(), 
				String.valueOf(TipoEmissaoNotaEnum.CONTINGENCIA.getId()));
		
		NotaFiscal notaContigencia = SerializationUtils.clone(notaFiscal);
		notaContigencia.setId(null);
		notaContigencia.setTx_nfnum(notaControle.getTx_ultima_nota());
		notaContigencia.setTx_serie(notaControle.getTx_serie());
		notaContigencia.setCs_contigencia(true); 
		notaContigencia.setTx_protocolo(StringUtility.EMPTY);
		notaContigencia.setCs_simulacao(false);
		notaContigencia.setTx_chave_acesso(novaChave);
		notaContigencia.setNb_sync(StatusNotaEnum.PENDENTE.getId());
		
		List<NotaItem> items = new ArrayList<NotaItem>();
		for(NotaItem item: notaContigencia.getNotaItems()) {
			NotaItem itemClone = SerializationUtils.clone(item);
			
			List<NotaItemCondicoes> condicoes = new ArrayList<NotaItemCondicoes>();
			for(NotaItemCondicoes condicao: item.getItemCondicoes()) {
				NotaItemCondicoes condicaoClone = SerializationUtils.clone(condicao);
				condicaoClone.setId(null);
				condicaoClone.setTx_nota_item(itemClone);
				condicoes.add(condicaoClone);
			}
			
			itemClone.setId(null);
			itemClone.setTx_nota_fiscal(notaContigencia);
			itemClone.setItemCondicoesTemp(condicoes);
			items.add(itemClone);
		}
		notaContigencia.setNotaItemsTemp(items);
		
		NotaFiscal notaGravada = database.getNotaFiscal().gravarNotaContigencia(notaContigencia);
		
		return notaGravada;
	}
	
	
	public static List<DescontosDto> getDescontosNota(NotaFiscal notaFiscal) {
		double ZFD1vl = 0;
		double ZFD2vl = 0;
		double ZFD5vl = 0;
		
		for(NotaItem notaItem: notaFiscal.getNotaItems()) {
			ForeignCollection<NotaItemCondicoes> itemCondicoes = notaItem.getItemCondicoes();
			for (NotaItemCondicoes condicao : itemCondicoes) {
				if(CondicoesEnum.ZFD1.getCodigo().equals(condicao.getTx_condicao())) {
					ZFD1vl += condicao.getVl_total().doubleValue();
				} else if(CondicoesEnum.ZFD2.getCodigo().equals(condicao.getTx_condicao())) {
					ZFD2vl += condicao.getVl_total().doubleValue();
				} else if(CondicoesEnum.ZFD5.getCodigo().equals(condicao.getTx_condicao())) {
					ZFD5vl += condicao.getVl_total().doubleValue();
				}
			}
		}
		
		List<DescontosDto> descontos = new ArrayList<DescontosDto>();
		if(ZFD1vl > 0) {
			descontos.add(new DescontosDto(CondicoesEnum.ZFD1, new BigDecimal(ZFD1vl)));
		} else if(ZFD2vl > 0) {
			descontos.add(new DescontosDto(CondicoesEnum.ZFD2, new BigDecimal(ZFD2vl)));
		} else if(ZFD5vl > 0) {
			descontos.add(new DescontosDto(CondicoesEnum.ZFD5, new BigDecimal(ZFD5vl)));
		}
		
		return descontos;
	}
}